package com.xlh.service.course;

import com.xlh.dto.course.*;
import com.xlh.dto.system.OperationDTO;
import com.xlh.dto.user.UserInfoDTO;
import com.xlh.enums.ResourceRelationTypeEnum;
import com.xlh.enums.ResourcesTypeEnum;
import com.xlh.enums.SchoolTypeEnum;
import com.xlh.enums.course.*;
import com.xlh.enums.courseTest.PaperStatusEnum;
import com.xlh.enums.courseTest.QuestionOriginEnum;
import com.xlh.param.course.*;
import com.xlh.pojo.course.Chapter;
import com.xlh.pojo.course.ChapterBasic;
import com.xlh.pojo.course.ChapterCourseSort;
import com.xlh.pojo.system.Resource;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;
import java.util.Map;

/**
 * 章节
 * <p>
 * Created by lx on 2019/1/28.
 */
public interface ChapterService {

    /**
     * 根据课程id，获取未删除的章节关联
     *
     * @param courseId    课程id
     * @param chapterEnum 章节枚举
     * @return
     */
    List<Chapter> getChapter(Long courseId, ChapterEnum chapterEnum);

    /**
     * 根据课程id、章节id集合，获取章节基本信息
     *
     * @param courseId    课程id
     * @param chapterIds  章节id集合
     * @param types       类型集合
     * @param chapterEnum 章节枚举
     * @return
     */
    List<ChapterBasic> getChapterBasic(
            Long courseId, List<Long> chapterIds, List<Integer> types, ChapterEnum chapterEnum);

    /**
     * 获取章节
     *
     * @param courseIds   课程id集合
     * @param ids         章节id集合
     * @param types       章节类型
     * @param chapterEnum 章节枚举
     * @return
     */
    List<ChapterBasicInfoDTO> listChapter(
            List<Long> courseIds, List<Long> ids, List<Integer> types, ChapterEnum chapterEnum);

    /**
     * 获取章节
     *
     * @param courseIds 课程id集合
     * @param ids       章节id集合
     * @param types     章节类型
     * @return
     */
    List<ChapterBasicInfoDTO> listChapterInfo(List<Long> courseIds, List<Long> ids, List<Integer> types);

    /**
     * 获取任务数据
     *
     * @param parentIds 父级（任务）id集合
     * @param info      任务信息
     * @return
     */
    List<ChapterBasicInfoDTO> listTask(List<Long> parentIds, String info);

    /**
     * 按顺序获取任务数据
     *
     * @param courseIds 课程id集合
     * @param types     类型
     * @param flag      是否过滤章节显隐标识 true：过滤   false/null：不过滤
     * @return
     */
    List<ChapterBasicInfoDTO> listTask(List<Long> courseIds, List<Integer> types, Boolean flag);

    /**
     * 获取章节技能
     *
     * @param courseIds 课程id集合
     * @return
     */
    List<ChapterBasicInfoDTO> queryChapterTechnology(List<Long> courseIds);

    /**
     * 根据课程id 获取当前课程的章节信息
     *
     * @param courseId 课程id
     * @return
     */
    List<ChapterBasicDTO> listChapter(Long courseId);

    /**
     * 根据课程id 获取当前课程的章节信息
     *
     * @param courseId 课程id
     * @return
     */
    List<ChapterBasicInfoDTO> listChapterInfo(Long courseId);

    /**
     * 转换章节信息
     *
     * @param chapterConvertTypeEnum 章节转换类型枚举
     * @param data                   数据
     * @param userCourseStatusEnum   用户课程状态枚举
     * @param studiedChapterIds      已学完章节id
     * @param practiceExistMap       随堂练习是否存在
     * @param chapterPracticeMap     章节评价集合
     * @param courseSortData         课程分类数据
     * @param operationDTO           最近学习的章节信息
     * @param courseSchoolTypeEnums  学校类型
     * @return
     */
    List<ChapterBasicDTO> convertChapterBasic(
            ChapterConvertTypeEnum chapterConvertTypeEnum, List<ChapterBasicDTO> data,
            UserCourseStatusEnum userCourseStatusEnum, List<Long> studiedChapterIds,
            Map<Long, Boolean> practiceExistMap, Map<Long, PaperStatusEnum> chapterPracticeMap,
            List<ChapterBasicDTO> courseSortData, OperationDTO operationDTO,
            List<SchoolTypeEnum> courseSchoolTypeEnums);

    /**
     * 根据课程id 获取当前课程的章节信息
     *
     * @param courseIds 课程id集合
     * @return
     */
    List<ChapterBasicInfoDTO> listChapter(List<Long> courseIds);

    /**
     * 修改某课程下的某班级的某类型资源
     *
     * @param courseId 课程id
     * @param params   修改的参数集合
     * @param typeEnum 资源权限操作类型枚举
     */
    void updateResourceAuthority(Long courseId,
                                 List<UpdateResourceAuthorityParam> params, AuthorityOperatingTypeEnum typeEnum);


    /**
     * 获取章节资源信息
     *
     * @param courseId           课程id
     * @param chapterId          章节id
     * @param stepChapterId      步骤与章节的id
     * @param resourcesTypeEnums 资源类型枚举集合
     * @return
     */
    Map<String, ResourceInfoDTO> queryChapterResourceInfo(Long courseId, Long chapterId, Long stepChapterId,
                                                          List<ResourcesTypeEnum> resourcesTypeEnums);

    /**
     * 获取笔记内容
     *
     * @param courseId      课程id
     * @param chapterId     章节id
     * @param notesTypeEnum 笔记类型枚举
     * @param pageNumber    页数
     * @return
     */
    String getNotesContent(Long courseId, Long chapterId, NotesTypeEnum notesTypeEnum, Integer pageNumber);

    /**
     * 修改笔记内容
     *
     * @param chapterId 章节id
     * @param param     参数
     * @return
     */
    void updateNotesContent(Long courseId, Long chapterId, NotesParam param);

    /**
     * 根据章节id获取默认班级的教师信息
     *
     * @param chapterId 章节id
     * @return
     */
    List<UserInfoDTO> getChapterTeacher(Long chapterId);

    /**
     * 查询章节的当前上课的学生
     *
     * @param chapterId 章节id
     * @return
     */
    List<UserInfoDTO> listStudent(Long chapterId);

    /**
     * 查询当前学生是否为章节当前上课的学生
     *
     * @param chapterId 章节id
     * @param userId    用户id
     * @return
     */
    Boolean isDefaultStudent(Long chapterId, Long userId);

    /**
     * 根据章节id获取章节基本信息
     *
     * @param chapterId 章节id
     * @return
     */
    ChapterBasic getChapterInfo(Long chapterId);

    /**
     * 存在的数据
     *
     * @param technologyIds 技能id集合
     * @return
     */
    List<Long> existTechnologyIds(List<Long> technologyIds);

    /**
     * 创建章节
     *
     * @param courseId     课程id
     * @param chapterParam 创建章节参数
     */
    void createChapter(Long courseId, ChapterParam chapterParam);

    /**
     * 创建章节
     *
     * @param chapterBasic 基本信息
     * @param chapter      章节
     */
    void createChapter(ChapterBasic chapterBasic, Chapter chapter);

    /**
     * 修改章节
     *
     * @param courseId     课程id
     * @param chapterId    章节id
     * @param chapterParam 修改参数
     * @param logicDeleted 是否逻辑删除 true：逻辑删除（假删除） false：真删除
     */
    void updateChapterInfo(Long courseId, Long chapterId, ChapterParam chapterParam, Boolean logicDeleted);

    /**
     * 修改章节基本信息或章节
     *
     * @param chapterBasic  章节基本信息
     * @param dbChapterData 数据库章节基本信息
     * @param chapterEnum   章节类型
     */
    void updateChapterBasicsOrChapter(
            ChapterBasic chapterBasic, ChapterBasicInfoDTO dbChapterData, ChapterEnum chapterEnum);

    /**
     * 修改章节
     *
     * @param chapter 章节
     */
    void updateChapterSelective(Chapter chapter);

    /**
     * 修改章节
     *
     * @param courseId  课程id
     * @param chapterId 章节id
     * @param flag      标识
     * @param type      类型
     */
    void updateChapterFalg(Long courseId, Long chapterId, Boolean flag, Integer type);

    Integer getClipboardFalg(Long courseId, Long chapterId);

    /**
     * 删除课程下的章节
     *
     * @param courseIds       课程id集合
     * @param chapterIds      章节id集合 可以不传，不传则删除课程下的全部章节
     * @param logicDeleted    是否逻辑删除 true：逻辑删除（假删除） false：真删除
     * @param deleteResources 是否删除资源 true：删除 false：不删除
     * @param updatePreseted  是否修改为预置课程 true：修改 false：不修改
     * @return 资源静态文件名称集合
     */
    List<String> deleteChapter(
            List<Long> courseIds, List<Long> chapterIds, Boolean logicDeleted,
            Boolean deleteResources, Boolean updatePreseted);

    /**
     * 删除课程下的章节
     *
     * @param courseIds    课程id集合
     * @param chapterIds   章节id集合
     * @param logicDeleted 是否逻辑删除 true：逻辑删除（假删除） false：真删除
     * @return
     */
    List<ChapterBasicInfoDTO> deleteChapterInfo(
            List<Long> courseIds, List<Long> chapterIds, Boolean logicDeleted);

    /**
     * 删除资源并获取资源路径
     *
     * @param objIds                   删除对象id集合
     * @param types                    类型集合
     * @param name                     名称
     * @param resourceRelationTypeEnum 资源关联关系类型枚举
     * @return
     */
    List<String> deleteAndGetResourceRelation(List<Long> objIds, List<Integer> types, String name,
                                              ResourceRelationTypeEnum resourceRelationTypeEnum);

    /**
     * 删除静态资源
     *
     * @param names 资源名称集合
     */
    void deleteStaticResources(List<String> names);

    /**
     * 获取预置、自定义课程章节
     *
     * @param courseId   课程id
     * @param originEnum 类型
     * @return
     */
    List<ZtreeDTO> getCourseChapterByType(Long courseId, QuestionOriginEnum originEnum);

    /**
     * 导入存在的章节
     *
     * @param sourceCourseId 原课程id 可不传
     * @param targetCourseId 目标课程id
     * @param chapterTaskIds 章节id和任务id集合
     * @return
     */
    Map<Long, Long> importExistChapter(Long sourceCourseId, Long targetCourseId, List<Long> chapterTaskIds);

    /**
     * 调整章节顺序
     *
     * @param courseId   课程id
     * @param chapterIds 章节id集合
     */
    void orderAdjustmentsChapter(Long courseId, List<Long> chapterIds);

    /**
     * 获取自己某课程的章节
     *
     * @param courseId 课程id
     * @return
     */
    List<ZtreeDTO> getChapterOwner(Long courseId);

    /**
     * 创建或修改某章节资源
     *
     * @param courseId  课程id
     * @param chapterId 章节id
     * @param stepId    步骤id
     * @param typeEnum  类型枚举
     * @param files     多个文件
     * @param param     参数
     */
    void createOrUpdateResource(Long courseId, Long chapterId, Long stepId, ResourcesTypeEnum typeEnum,
                                MultipartFile[] files, CreateResourceParam param);

    /**
     * 创建/修改课程资源
     *
     * @param courseId   课程id
     * @param resourceId 资源id
     */
    Long createOrUpdateResource(Long courseId, Long resourceId);


    /**
     * 删除某章节资源
     *
     * @param courseId      课程id
     * @param chapterId     章节id
     * @param stepChapterId 步骤与章节的id
     * @param typeEnum      类型枚举
     * @param name          名称
     */
    void deleteResource(Long courseId, Long chapterId, Long stepChapterId, ResourcesTypeEnum typeEnum, String name);

    /**
     * 获取资源权限
     *
     * @param userId          教师id
     * @param typeEnumListMap 资源类型枚举
     * @param typeEnum        操作枚举
     * @param objIds          对象id集合
     * @return
     */
    Map<Long, List<ResourceAuthorityDTO>> queryResourceAuthority(Long userId,
                                                                 Map<ResourcesTypeEnum, List<String>> typeEnumListMap,
                                                                 AuthorityOperatingTypeEnum typeEnum, List<Long> objIds);

    /**
     * 删除笔记
     *
     * @param chapterIds     章节id集合
     * @param userIds        用户id集合
     * @param notesTypeEnums 笔记类型集合
     * @return
     */
    List<String> deleteNotes(List<Long> chapterIds, List<Long> userIds, List<NotesTypeEnum> notesTypeEnums);

    /**
     * 获取资源信息
     *
     * @param type     类型
     * @param fileName 文件名
     * @param remark   备注
     * @return
     */
    List<Resource> getResource(Integer type, String fileName, String remark);

    /**
     * 删除资源权限
     *
     * @param typeEnum 类型枚举
     * @param objIds   删除对象id集合
     */
    void deleteResourceAuthority(AuthorityOperatingTypeEnum typeEnum, List<Long> objIds);

    /**
     * 获取资源
     *
     * @param courseId 课程id
     * @param param    文件参数
     * @return
     */
    void checkResource(Long courseId, FileParam param);

    /**
     * 获取token的值并删除token的值
     *
     * @param token
     */
    FileParam getTokenValueAndRemove(String token);

    /**
     * 根据章节Id查询课程Id
     *
     * @param chapterId 章节Id
     * @return
     */
    Long getCourseIdByChapterId(Long chapterId);

    /**
     * 获取章节课程分类的关联关系
     *
     * @param courseSortIds 课程分类id集合
     * @param chapterIds    章节id集合
     * @return
     */
    List<ChapterCourseSort> queryChapterCourseSort(List<Long> courseSortIds, List<Long> chapterIds);

    /**
     * 删除章节的课程分类
     *
     * @param courseSortIds 课程分类id集合
     * @param chapterIds    章节id集合
     */
    void deleteChapterCourseSort(List<Long> courseSortIds, List<Long> chapterIds);

    /**
     * 创建课程及章节的分类
     *
     * @param courseId 课程id
     * @param params   参数
     */
    void createOrUpdateChapterCourseSort(Long courseId, List<CreateChapterCourseSortParam> params);

    /**
     * 获取章节及课程分类的关联关系
     *
     * @param courseId 课程id
     * @return
     */
    List<CourseSortDTO> listChapterCourseSort(Long courseId);

    /**
     * 批量修改章节顺序
     *
     * @param chapters 章节数据
     */
    void updateBatch(List<Chapter> chapters);

    /**
     * 添加资源
     *
     * @param type     资源类型
     * @param name     名称
     * @param fileName 文件名
     * @param remark   备注
     * @return
     */
    Long insertResource(Integer type, String name, String fileName, String remark);

    /**
     * 批量插入章节基本信息
     *
     * @param chapterBasics 章节基本信息
     */
    void insertBatchChapterBasic(List<ChapterBasic> chapterBasics);

    /**
     * 批量插入章节
     *
     * @param chapters 章节信息
     */
    void insertBatchChapter(List<Chapter> chapters);

    /**
     * 批量插入章节课程分类
     *
     * @param chapterCourseSorts 插入数据
     */
    void insertBatchChapterCourseSort(List<ChapterCourseSort> chapterCourseSorts);

    /**
     * 获取课程下的章节/任务
     *
     * @param courseId    课程
     * @param chapterEnum 章节枚举
     * @param typeEnum    步骤类型枚举
     * @return
     */
    List<ChapterBasicInfoDTO> listChapterByStepType(Long courseId, ChapterEnum chapterEnum, StepTypeEnum typeEnum, List<ChapterTypeEnum> types);

}
